home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 17 / CU Amiga Magazine's Super CD-ROM 17 (1997)(EMAP Images)(GB)[!][issue 1997-12].iso / CUCD / Programming / DiceSource / src / dd / registers.c < prev    next >
C/C++ Source or Header  |  1997-09-09  |  5KB  |  228 lines
  1. /*
  2.  *    (c)Copyright 1992-1997 Obvious Implementations Corp.  Redistribution and
  3.  *    use is allowed under the terms of the DICE-LICENSE FILE,
  4.  *    DICE-LICENSE.TXT.
  5.  */
  6. #include    "defs.h"
  7. #include    "dbug_protos.h"
  8.  
  9. // ************************************************************************
  10.  
  11. Local BOOL        RefreshRegister(char *regName, ULONG current, ULONG last);
  12. Prototype char        *StateText(ULONG staten);
  13. Local void        DisplayFlags(void);
  14. Prototype WORD        RefreshRegisters(WORD maxLines, BOOL fullRefresh);
  15. Prototype long        *RegisterAddress(char *name);
  16.  
  17.  
  18. // ************************************************************************
  19.  
  20. ULONG        programState = STATE_EXITED;
  21. UWORD        programSR;
  22. ULONG        programPC;
  23. ULONG        programD0;
  24. ULONG        programD1;
  25. ULONG        programD2;
  26. ULONG        programD3;
  27. ULONG        programD4;
  28. ULONG        programD5;
  29. ULONG        programD6;
  30. ULONG        programD7;
  31. ULONG        programA0;
  32. ULONG        programA1;
  33. ULONG        programA2;
  34. ULONG        programA3;
  35. ULONG        programA4;
  36. ULONG        programA5;
  37. ULONG        programA6;
  38. ULONG        programA7;
  39.  
  40. ULONG        lastState = STATE_EXITED;
  41. UWORD        lastSR;
  42. ULONG        lastPC;
  43. ULONG        lastD0;
  44. ULONG        lastD1;
  45. ULONG        lastD2;
  46. ULONG        lastD3;
  47. ULONG        lastD4;
  48. ULONG        lastD5;
  49. ULONG        lastD6;
  50. ULONG        lastD7;
  51. ULONG        lastA0;
  52. ULONG        lastA1;
  53. ULONG        lastA2;
  54. ULONG        lastA3;
  55. ULONG        lastA4;
  56. ULONG        lastA5;
  57. ULONG        lastA6;
  58. ULONG        lastA7;
  59.  
  60. Local BOOL    RefreshRegister(char *regName, ULONG current, ULONG last) {
  61.     ScrPlain();
  62.     ScrPrintf("%s: ", regName);
  63.     if (current != last)ScrHighlight();
  64.     ScrPrintf("$%08X ", current);
  65. }
  66.  
  67. struct {
  68.     ULONG    state;
  69.     char    *text;
  70. } stateTable[] = {
  71.     { 0,    "RUNNING             " },
  72.     { 1,    "HALTED              " },
  73.     { 2,    "BUS_ERROR           " },
  74.     { 3,    "ADDRESS_ERROR       " },
  75.     { 4,    "ILLEGAL_INSTRUCTION " },
  76.     { 5,    "ZERO_DIVIDE         " },
  77.     { 6,    "CHK                 " },
  78.     { 7,    "TRAPV               " },
  79.     { 8,    "PRIVILEGE_VIOLATION" },
  80.     { 9,    "TRACE               " },
  81.     { 10,    "LINEA               " },
  82.     { 11,    "LINEF               " },
  83.     { 64,    "RESET               " },
  84.     { 65,    "EXITED              " },
  85.     { 66,    "STEPPED             " },
  86.     { 67,    "STEPPEDOVER         " },
  87.     { 68,    "BREAKPOINT HIT      " },
  88.     { 69,    "GOSTEP              " },
  89.     { 512,    "UNDEFINED           " },
  90. };
  91.  
  92. char    *StateText(ULONG state) {
  93.     short    i;
  94.  
  95.     for (i=0; stateTable[i].state != state && stateTable[i].state != 512; i++);
  96.     return stateTable[i].text;
  97. }
  98.  
  99. Local void    DisplayFlags(void) {
  100.     ScrPlain();
  101. //    ScrPrintf("T=%c ", (programSR & 0x8000) ? '1' : '0');
  102. //    ScrPrintf("S=%c ", (programSR & 0x2000) ? '1' : '0');
  103.     ScrPrintf("X=%c ", (programSR & 0x0010) ? '1' : '0');
  104.     ScrPrintf("N=%c ", (programSR & 0x0008) ? '1' : '0');
  105.     ScrPrintf("Z=%c ", (programSR & 0x0004) ? '1' : '0');
  106.     ScrPrintf("V=%c ", (programSR & 0x0002) ? '1' : '0');
  107.     ScrPrintf("C=%c ", (programSR & 0x0001) ? '1' : '0');
  108. //    ScrPrintf("IM=%d ",  (programSR>>8)&7);
  109. }
  110.  
  111. WORD    RefreshRegisters(WORD maxLines, BOOL fullRefresh) {
  112.     WORD    count = 0;
  113.  
  114.     if(CurDisplay->ds_RegFlag) {
  115.  
  116.     RefreshRegister("D0", programD0, lastD0);
  117.     RefreshRegister("D1", programD1, lastD1);
  118.     RefreshRegister("D2", programD2, lastD2);
  119.     RefreshRegister("D3", programD3, lastD3);
  120.     count++; 
  121.     Newline(); 
  122.     maxLines--; 
  123.     if (!maxLines) return count;
  124.  
  125.     RefreshRegister("D4", programD4, lastD4);
  126.     RefreshRegister("D5", programD5, lastD5);
  127.     RefreshRegister("D6", programD6, lastD6);
  128.     RefreshRegister("D7", programD7, lastD7);
  129.     count++; Newline(); maxLines--; if (!maxLines) return count;
  130.  
  131.     RefreshRegister("A0", programA0, lastA0);
  132.     RefreshRegister("A1", programA1, lastA1);
  133.     RefreshRegister("A2", programA2, lastA2);
  134.     RefreshRegister("A3", programA3, lastA3);
  135.     count++; Newline(); maxLines--; if (!maxLines) return count;
  136.  
  137.     RefreshRegister("A4", programA4, lastA4);
  138.     RefreshRegister("A5", programA5, lastA5);
  139.     RefreshRegister("A6", programA6, lastA6);
  140.     RefreshRegister("A7", programA7, lastA7);
  141.     count++; Newline(); maxLines--; if (!maxLines) return count;
  142.  
  143.     RefreshRegister("PC", programPC, lastPC);
  144.     ScrPlain();
  145.     ScrPrintf("SR: ");
  146.     if (programSR != lastSR)ScrHighlight();
  147.     ScrPrintf("$%04X ", programSR);
  148.     DisplayFlags();
  149.     ScrPlain();
  150.     ScrPrintf("STATE: ");
  151.     if (programState != lastState)
  152.         ScrHighlight();
  153.     ScrPrintf("%s", StateText(programState));
  154.     count++; Newline(); maxLines--; if (!maxLines) return count;
  155.     }
  156.     return count;
  157. }
  158.  
  159. /*
  160.  *  RegisterAddress()    - Given a valid two character register specification
  161.  *              return a pointer to the storage are for the reg.
  162.  *
  163.  *              return NULL if the two char specification is
  164.  *              illegal.
  165.  */
  166.  
  167. long   *RegisterAddress(char *name)
  168. {
  169.     char c = name[1];
  170.  
  171.     switch(name[0]) {
  172.     case 'a':
  173.     case 'A':
  174.         switch(c) {
  175.         case '0':
  176.         return(&programA0);
  177.         case '1':
  178.         return(&programA1);
  179.         case '2':
  180.         return(&programA2);
  181.         case '3':
  182.         return(&programA3);
  183.         case '4':
  184.         return(&programA4);
  185.         case '5':
  186.         return(&programA5);
  187.         case '6':
  188.         return(&programA6);
  189.         case '7':
  190.         return(&programA7);
  191.         }
  192.         break;
  193.     case 'd':
  194.     case 'D':
  195.         switch(c) {
  196.         case '0':
  197.         return(&programD0);
  198.         case '1':
  199.         return(&programD1);
  200.         case '2':
  201.         return(&programD2);
  202.         case '3':
  203.         return(&programD3);
  204.         case '4':
  205.         return(&programD4);
  206.         case '5':
  207.         return(&programD5);
  208.         case '6':
  209.         return(&programD6);
  210.         case '7':
  211.         return(&programD7);
  212.         }
  213.         break;
  214.     case 'p':
  215.     case 'P':
  216.         if (c == 'c' || c == 'C')
  217.         return(&programPC);
  218.         break;
  219.     case 's':
  220.     case 'S':
  221.         if (c == 'p' || c == 'P')
  222.         return(&programA7);
  223.         break;
  224.     }
  225.     return(NULL);
  226. }
  227.  
  228.